package com.dkd.day20250817;

import java.util.Scanner;

public class copyTest1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int volunteer = sc.nextInt();
        int n = sc.nextInt();
        int [] communities = new int[n];
        for (int i = 0; i < n; i++) {
            communities[i] = sc.nextInt();
        }

        System.out.println(solve(volunteer, communities));
    }

    public static int solve(int num, int[] communities) {
        // --- 步骤 1: 确定二分查找的范围 ---
        long totalHours = 0; // 所有社区的总工作量，使用long防止溢出
        int maxSingleCommunityHours = 0; // 单个社区的最大工作量

        for (int hours : communities) {
            totalHours += hours;
            maxSingleCommunityHours = Math.max(maxSingleCommunityHours, hours);
        }

        // 搜索范围的下界(left):
        // 至少需要的时间是处理最大单个社区所需的时间，因为一个社区不能拆分给多个志愿者。
        long left = maxSingleCommunityHours;
        // 搜索范围的上界(right):
        // 最坏的情况下，一个志愿者处理所有社区，所需时间是所有社区工作量之和。
        long right = totalHours;

        // 用于存储最终找到的最小可行时间
        long minTimeResult = right;

        // --- 步骤 2: 执行二分查找 ---
        while (left <= right) {
            // 计算中间值作为本次猜测的“最短完成时间”
            long midTime = left + (right - left) / 2;

            // 检查使用 num 个志愿者，是否能在 midTime 小时内完成所有任务
            if (canFinish(midTime, num, communities)) {
                // 如果可以完成，说明 midTime 是一个可行的解。
                // 我们记录下这个解，并尝试寻找一个更小的时间。
                minTimeResult = midTime;
                right = midTime - 1;
            } else {
                // 如果不能完成，说明 midTime 这个时间太短了，需要增加时间。
                left = midTime + 1;
            }
        }

        return (int) minTimeResult;

    }

    private static boolean canFinish(long timeLimit, int numVolunteers, int[] communities) {
        // 需要的志愿者数量，初始为1（至少需要一个人开始工作）
        int volunteersNeeded = 1;
        // 当前这个志愿者已经分配的工作量
        long currentVolunteerWorkload = 0;

        // 使用贪心策略，按顺序为志愿者分配连续的社区
        for (int communityHours : communities) {
            // 如果单个社区的工作量就超过了时间限制，那么这个时间限制是绝对不可能实现的。
            // (虽然我们的二分查找下界已经保证了这种情况不会发生，但这是一个稳健性检查)
            if (communityHours > timeLimit) {
                return false;
            }

            // 尝试将当前社区分配给正在工作的志愿者
            if (currentVolunteerWorkload + communityHours <= timeLimit) {
                // 如果没超时，就累加工作量
                currentVolunteerWorkload += communityHours;
            } else {
                // 如果超时了，就需要一个新的志愿者
                volunteersNeeded++;
                // 这个新志愿者的工作量从当前这个社区开始计算
                currentVolunteerWorkload = communityHours;
            }
        }

        // 循环结束后，比较需要的志愿者数量和可用的志愿者数量
        return volunteersNeeded <= numVolunteers;
    }

}
